﻿// ***********************************************************************
// Assembly         : Delta_util
// Author           : Juan Alberto Cerino Gomez
// Created          : 02-18-2013
//
// Last Modified By : Juan Alberto Cerino Gomez
// Last Modified On : 05-31-2013
// ***********************************************************************
// <copyright file="Utilerias.cs" company="Delta Bussines">
//     Copyright (c) 2013  Delta Bussines. All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.UI.WebControls;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Collections.Specialized;
using System.Web.UI.HtmlControls;
using System.Data;
using Delta_util.Estaticos;
using System.Runtime.InteropServices;
using System.Management;
using System.IO;

namespace Delta_util.Clases
{
    /// <summary>
    /// Clase que contiene metodos utiles para realizar operaciones en controles WEB.
    /// </summary>
    public class Utilerias
    {

        /// <summary>
        /// Metodo que se encarga de obtener la url raiz de una aplicación WEB.
        /// </summary>
        /// <param name="pagina">La pagina de la cual se leerá la URL.</param>
        /// <returns>Devuelve el valor(System.String) que contiene la url del sito, por ejemplo http://www.misitio.com/admin/</returns>
        public static string ObtenerHttpServer(Page pagina)
        {
            string url = "";
            if (pagina != null)
                url = "http://" + pagina.Request.Url.Authority + pagina.Request.ApplicationPath;

            if (!url.EndsWith("/"))
                url += "/";

            return url;
        }
        /// <summary>
        /// Metodo que se encarga de obtener la url raiz de una aplicación WEB.
        /// </summary>
        /// <param name="pagina">La pagina de la cual se leerá la URL.</param>
        /// <returns>Devuelve el valor(System.String) que contiene la url del sito, por ejemplo http://www.misitio.com/admin/</returns>
        public static string ObtenerHttpServer(HttpContext pagina)
        {

            if (pagina != null)
                return "http://" + pagina.Request.Url.Authority + pagina.Request.ApplicationPath;
            else
                return "";
        }
        //public static PropertyInfo ObtenerPropiedadXAtributoXNombre<TA>(Type tipo, string nombre) where TA : System.Attribute
        //{

        //    var lista = from prop in tipo.GetProperties() where prop.Name == nombre && prop.GetCustomAttributes(typeof(TA), false).Length > 0 select prop;
        //    if (lista != null && lista.Count() > 0)
        //        return lista.First<PropertyInfo>();
        //    else
        //        return null;

        //}

        /// <summary>
        /// Metodo generico que se encarga de obtener los atributos a nivel clase, personalizados en un tipo de dato o entidad.
        /// </summary>
        /// <typeparam name="TA">El tipo del atributo a buscar.</typeparam>
        /// <param name="tipo">El tipo de dato en el cual se realiza la busqueda del atributo.</param>
        /// <returns>Devuelve la información del atributo, si no se encuentra el atributo, devuelve un valor nulo.</returns>
        public static TA ObtenerAtributoPropiedad<TA>(Type tipo) where TA : System.Attribute
        {

            var lista = from prop in tipo.GetCustomAttributes(true) where prop.GetType() == typeof(TA) select prop;
            if (lista.Count() > 0)
                return (TA)lista.First();
            else
                return default(TA);

        }

        /// <summary>
        /// Metodo generico que se encarga de obtener un atributo personalizado a nivel propiedad, en un tipo de dato o entidad.
        /// </summary>
        /// <typeparam name="TA">El tipo del atributo a buscar.</typeparam>
        /// <param name="tipo">El tipo de dato en el cual se realiza la busqueda del atributo.</param>
        /// <returns>Lista que contiene los atributos encontrados en el tipo, devuelve un valor nul si no se encuentran propiedades que contengan el atributo buscado.</returns>
        public static List<PropertyInfo> ObtenerPropiedadesXAtributo<TA>(Type tipo) where TA : System.Attribute
        {

            var lista = from prop in tipo.GetProperties() where prop.GetCustomAttributes(typeof(TA), false).Length > 0 select prop;

            if (lista != null && lista.Count() > 0)
                return lista.ToList<PropertyInfo>();
            else
                return null;

        }

        /// <summary>
        /// Metodo que se encarga de validar si una entidad existe en un DatView, de acuerdo a los campos llaves de un GridView.
        /// </summary>
        /// <param name="grd">El GridView que contiene los campos llaves y el DataView como fuente de datos.</param>
        /// <param name="entidad">La entidad a buscar.</param>
        /// <returns>Valor que indica si existe la entidad en el DataView.</returns>
        public static bool ExisteClaveEnDataView(GridView grd, dynamic entidad)
        {
            bool existe = false;
            int fila = 0;
            int validos = 0;
            if (grd != null && grd.DataKeyNames.Count() > 0 && entidad != null && grd.DataSource != null)
            {
                DataView dv = grd.DataSource as DataView;
                while (!existe && fila < dv.Count)
                {
                    validos = 0;
                    foreach (string claves in grd.DataKeyNames)
                    {
                        if (dv[fila][claves].Equals(entidad.ObtenerValor(claves)))
                            validos++;
                        else
                            break;
                    }
                    existe = (validos == grd.DataKeyNames.Count() && validos > 0);
                    fila++;
                }

            }

            return existe;
        }

        //public static bool ExisteClaveEnGrid(GridView grd, dynamic entidad)
        //{
        //    bool existe = false;
        //    int fila = 0;
        //    int validos = 0;
        //    if (grd != null && grd.DataKeyNames.Count() > 0 && entidad != null)
        //    {
        //        while (!existe && fila < grd.Rows.Count)
        //        {
        //            foreach (string claves in grd.DataKeyNames)
        //            {
        //                if (grd.DataKeys[fila][claves].Equals(entidad.ObtenerValor(claves)))
        //                    validos++;
        //                else
        //                    return false;
        //            }
        //            fila++;
        //        }
        //        existe = (validos == grd.Rows.Count && validos > 0);
        //    }

        //    return existe;
        //}


        /// <summary>
        /// Metodo que se encarga de encriptar una cadena de caracteres.
        /// </summary>
        /// <param name="cadena">El texto a encriptar.</param>
        /// <param name="config">Las llaves que se van a usar para encriptar el texto.</param>
        /// <returns>Devuelve un valor(System.String) que contiene el texto encriptado.</returns>
        public static string Encriptar(string cadena, string[] config)
        {
            if (string.IsNullOrWhiteSpace(cadena))
                return "";
            else
            {

                //return Encriptar(cadena);
                Encriptacion nclase = new Encriptacion(config[0], config[1]);
                return nclase.Encripta(cadena);

            }
        }

        /// <summary>
        /// Obteners the valores claves grid.
        /// </summary>
        /// <param name="grid">The grid.</param>
        /// <param name="indice">The indice.</param>
        /// <returns>System.Collections.Hashtable.</returns>
        public static Dictionary<string,object> ObtenerValoresClavesGrid(GridView grid, int indice)
        {
            Dictionary<string, object> datos = new Dictionary<string, object>();

            for (int x = 0; x < grid.DataKeyNames.Count(); x++)
            {
                datos.Add(grid.DataKeyNames[x], grid.DataKeys[indice].Values[grid.DataKeyNames[x]]);
            }
            return datos;
        }
        /// <summary>
        /// Metodo que se encarga de convertir un valor a logico, si el valor no se puede convertir a logico, devuelve true.
        /// </summary>
        /// <param name="estatus">El valor que se intentará convertir.</param>
        /// <returns>Devuelve el valor convertido a logico.</returns>
        public static bool DefinicionEstatusUI(object estatus)
        {
            if (estatus != null)
                return Comun.Convertir<bool>(estatus);
            else
                return true;
        }
        /// <summary>
        /// Metodo que se encarga de desencriptar una cadena de caracteres.
        /// </summary>
        /// <param name="cadena">El texto a desencriptar.</param>
        /// <param name="config">Las llaves que se van a usar para desencriptar el texto.</param>
        /// <returns>Devuelve un valor(System.String) que contiene el texto desencriptado.</returns>
        public static string DesEncriptar(string cadena, string[] config)
        {
            Encriptacion nclase = new Encriptacion(config[0], config[1]);
            return nclase.Desencriptar(cadena);
        }

        /// <summary>
        /// Metodo que se encarga de obtener el valor de un parametro GET, de un HttpContext.
        /// </summary>
        /// <param name="pagina">Contexto el cual contiene el parametro.</param>
        /// <param name="clave">Nombre del parametro que se quiere obtener.</param>
        /// <returns>Devuelve el valor del parametro representado como "System.String", devuelve cadena vacia si no se encuentra el parametro.</returns>
        public static string ObtenerValorGET(HttpContext pagina, string clave)
        {
            if (pagina.Request[clave] != null)
            {
                return pagina.Request[clave];
            }
            return "";
        }

        /// <summary>
        /// Metodo que se encarga de obtener el valor de un parametro GET, de una página.
        /// </summary>
        /// <param name="pagina">Página la cual contiene el parametro.</param>
        /// <param name="clave">Nombre del parametro que se quiere obtener.</param>
        /// <returns>Devuelve el valor del parametro representado como "System.String", devuelve cadena vacia si no se encuentra el parametro.</returns>
        public static string ObtenerValorGET(Page pagina, string clave)
        {
            if (pagina.Request[clave] != null)
            {
                return pagina.Request[clave];
            }
            return "";
        }

        /// <summary>
        /// Metodo que se encarga de obtener la descripción de una excepción.
        /// </summary>
        /// <param name="ex">Excepcion que contiene la información del error.</param>
        /// <returns>Devuelve la información del error, asi como todas las subexcepciones (InnerExcepcion) que contiene.</returns>
        public static string getMsgError(Exception ex)
        {
            string str = "";
            while (ex != null)
            {
                if (str == "")
                    str = ex.Message;
                else
                    str += "<INNNER>" + ex.Message;
                ex = ex.InnerException;
            }
            return str.Replace("'", "_").Replace("\"", "_").Replace("|", "$").Replace("\r", "").Trim();
        }

        /// <summary>
        /// Metodo que se encarga de serializar un objeto en formato JSON.
        /// </summary>
        /// <param name="Objeto">El objeto a representar en formato JSON.</param>
        /// <returns>Cadena que contiene la representación JSON del objeto, devuelve una cadena vacia si el objeto no se puede representar en formato JSON.</returns>
        public static string SerializarJSon(object Objeto)
        {
            try
            {

                return Newtonsoft.Json.JsonConvert.SerializeObject(Objeto);


            }
            catch (Exception ex) { return string.Empty; }

        }

        /// <summary>
        /// Se encarga de guardar una clase representada en JSON en el componente Hidden.
        /// </summary>
        /// <param name="memoria">El control Hidden en el cual se guardará la clase.</param>
        /// <param name="clase">Clase u objeto a serializar, el objeto debe aceptar la serialización.</param>
        /// <param name="keys">Las llaves que se usarán para encriptar la clase.</param>
        public static void GuardarClase(HiddenField memoria, object clase, string[] keys)
        {
            memoria.Value = Encriptar(SerializarJSon(clase), keys);
        }

        /// <summary>
        /// Metodo generico que se encarga de convertir una cadena JSON a un objeto.
        /// </summary>
        /// <typeparam name="T">Tipo de dato al cual se convertira la cadena JSON, devuelve un valor nulo si no se logra convetir la cadena JSON.</typeparam>
        /// <param name="memoria">Cadena que representa el objeto en formato JSON.</param>
        /// <param name="keys">Las llaves que se usarán para desencriptar la clase.</param>
        /// <returns>Deuvelve la representación en objeto(System.Object) de una cadena JSON, de acuerdo al tipo de dato especificado.</returns>
        public static T DeserializarJsonTo<T>(HiddenField memoria, string[] keys)
        {
            return DeserializarJsonTo<T>(DesEncriptar(memoria.Value, keys));
        }


        /// <summary>
        /// Metodo que se encarga de convertir una cadena JSON a un objeto, permitiendo indicar si la cadena esta encriptada.
        /// </summary>
        /// <param name="memoria">Cadena que representa el objeto en formato JSON.</param>
        /// <param name="keys">Las llaves que se usarán para desencriptar la clase.</param>
        /// <param name="tipo">Tipo de dato al cual se convertira la cadena JSON, devuelve un valor nulo si no se logra convetir la cadena JSON.</param>
        /// <param name="encriptado">Indica si la cadena JSON esta encriptado.</param>
        /// <returns>Deuvelve la representación en objeto(System.Object) de una cadena JSON, de acuerdo al tipo de dato especificado.</returns>
        public static object DeserializarJsonTo(string memoria, string[] keys, Type tipo, bool encriptado = true)
        {
            try
            {


                return Newtonsoft.Json.JsonConvert.DeserializeObject(encriptado ? DesEncriptar(memoria, keys) : memoria, tipo);

            }
            catch { return null; }
        }


        /// <summary>
        /// Metodo que se encarga de convertir una cadena JSON que se encuentra en un control Hidden a un objeto.
        /// </summary>
        /// <param name="memoria">El control Hidden en el cual se encuentra la cadena JSON.</param>
        /// <param name="keys">Las llaves que se usarán para desencriptar la clase.</param>
        /// <param name="tipo">Tipo de dato al cual se convertira la cadena JSON, devuelve un valor nulo si no se logra convetir la cadena JSON.</param>
        /// <returns>Deuvelve la representación en objeto(System.Object) de una cadena JSON, de acuerdo al tipo de dato especificado.</returns>
        public static object DeserializarJsonTo(HiddenField memoria, string[] keys, Type tipo)
        {
            try
            {

                return Newtonsoft.Json.JsonConvert.DeserializeObject(DesEncriptar(memoria.Value, keys), tipo);

            }
            catch { return null; }
        }

        /// <summary>
        /// Metodo generico que se encarga de convertir una cadena JSON a un objeto.
        /// </summary>
        /// <typeparam name="T">Tipo de dato al cual se convertirá la cadena JSON.</typeparam>
        /// <param name="jsonSerializado">Cadena JSON que representa un objeto o clase.</param>
        /// <returns>Deuvelve la representación en objeto de una cadena JSON, de acuerdo al tipo de dato especificado.</returns>
        public static T DeserializarJsonTo<T>(string jsonSerializado)
        {
            try
            {

                return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(jsonSerializado);

            }
            catch { return default(T); }
        }


        /// <summary>
        ///Metodo que se encarga de imprimir la funcion que devuelve la URL raiz del sitio.
        /// </summary>
        /// <param name="pagina">Página de la cual se leé la URL.</param>
        public static void ImprimirServer(Page pagina)
        {
            ExecScript(pagina, "function getServer(){return '" + ObtenerHttpServer(pagina) + "';}", "server");
        }

        /// <summary>
        /// Metodo que se encarga de ejecutar un script en una página.
        /// </summary>
        /// <param name="pagina">La página en la cual se imprime el script.</param>
        /// <param name="vscript">EL código javascript a imprimir.</param>
        /// <param name="nombre">Nombre identificador del segmento de código.</param>
        public static void ExecScript(ScriptManager pagina, string vscript, string nombre)
        {
            if (nombre == null)
                nombre = "script1";
            System.Text.StringBuilder script = new System.Text.StringBuilder();

            script.Append("<script type=\"text/javascript\"  language=\"javascript\">");
            script.Append("<!--  ");
            script.Append(vscript);
            script.Append(" //]]>");
            script.Append("</script>");
            pagina.Page.ClientScript.RegisterStartupScript(pagina.GetType(), nombre, vscript, true);
        }

        /// <summary>
        /// Metodo que se encarga de registrar un archivo jscript en una página web.
        /// </summary>
        /// <param name="pagina">Página web en la cual se incluirá el codigo jscript.</param>
        /// <param name="ruta">El Url del archivo javascript a incluir.</param>
        /// <param name="id">Nombre identificador del jscript.</param>
        public static void RegistrarJScript(Page pagina, string ruta, string id)
        {

            pagina.ClientScript.RegisterClientScriptInclude(pagina.GetType(), id, ObtenerHttpServer(pagina) + ruta);

        }
        /// <summary>
        /// Metodo que se encarga de cerrar las ventanas de espera al terminar de ejecutar la solicitud.
        /// </summary>
        /// <param name="pagina">Página que muestra el aviso.</param>
        public static void CerrarNotificacionesModal(Page pagina)
        {
            ExecScript(pagina, "CerrarMsgModal();", "cerrarModal", true);
        }
        /// <summary>
        /// Metodo que se encarga de ejecutar un fragmento de código javascript, permitiendo agregar la sentencia "try---catch".
        /// </summary>
        /// <param name="pagina">Página web en la cual se imprime el fragmento de código.</param>
        /// <param name="vscript">El codigo javascript a imprimir.</param>
        /// <param name="nombre">Nombre identificador del fragmento de código.</param>
        /// <param name="agregarTry">Indica si se debe incluir las etiquetas try-catch.</param>
        public static void ExecScript(Page pagina, string vscript, string nombre, bool agregarTry = false)
        {
            if (nombre == null)
                nombre = "script1";
            System.Text.StringBuilder script = new System.Text.StringBuilder();
            //vscript = pagina.Server.HtmlEncode(vscript);
            vscript = vscript.Replace("\n", "");
            script.Append("<script type=\"text/javascript\"  language=\"javascript\">");
            script.Append("<!--  ");
            if (agregarTry)
                script.Append("try{");
            script.Append(vscript);
            if (agregarTry)
                script.Append("}catch(ex){}");
            script.Append(" //]]>");
            script.Append("</script>");

            //pagina.ClientScript.RegisterStartupScript(pagina.GetType(),nombre, script.ToString(),true);

            //ClientScriptManager.RegisterStartupScript(pagina, pagina.GetType(), nombre, vscript, true);
            ScriptManager.RegisterStartupScript(pagina, pagina.GetType(), nombre, vscript, true);
        }


        /// <summary>
        /// Metodo que se encarga de imprimir la función de validación de un campo usando validacion REGEX.
        /// </summary>
        /// <param name="pagina">Página web en la cual se imprime la función.</param>
        /// <param name="ctrl">El control a validar.</param>
        /// <param name="campo">El nombre del campo dinamico al cual esta ligado el control web.</param>
        /// <param name="regex">La validacion REGEX a implementar.</param>
        /// <param name="textoError">El texto que se muestra al usuario cuando ingrese un dato que no cumple con la cadena REGEX.</param>
        /// <param name="tituloCampo">El tipo del campo dinamico enlazado al control web.</param>
        /// <param name="estilo">El estilo que se aplica al validador.</param>        
        /// <returns>Devuelve un control validador.</returns>
        public static CustomValidator FijarValidacionRegex(Page pagina, Control ctrl, string campo, string regex, string textoError = "No valido", string tituloCampo = null, string estilo = "errorValidador")
        {
            if (ctrl is WebControl && !string.IsNullOrWhiteSpace(regex))
            {
                CustomValidator val = new CustomValidator();
                string nombreFuncion = "val_" + campo;
                val.Display = ValidatorDisplay.Dynamic;
                val.CssClass = estilo;
                val.ClientValidationFunction = nombreFuncion;
                val.ControlToValidate = ctrl.ID;
                val.SetFocusOnError = true;
                val.ValidationGroup = "validacionEntidad";
                val.EnableClientScript = false;
                val.Text = string.Format(textoError, tituloCampo == null ? campo : tituloCampo);
                val.ErrorMessage = string.Format(textoError, tituloCampo == null ? campo : tituloCampo);
                Utilerias.ExecScript(pagina, " function " + nombreFuncion + @"(oSrc, args){var filter = /" + regex + "/; args.IsValid = filter.test(args.Value);}", nombreFuncion);
                return val;

            }
            else
                return null;
        }
        /// <summary>
        /// Metodo que se encarga de enlazar un archivo de estilos CSS, que se encuentra en una DLL, a una página web.
        /// </summary>
        /// <param name="pagina">Página web en la cual se enlazará la hoja de estilos.</param>
        /// <param name="tipo">Tipo en el cual se encuentra la hoja de estilos como WebResource.</param>
        /// <param name="css">Nombre completo de la ruta del archivo css en el ensamblado.</param>
        /// <returns>Devuelve un valor(HtmlLink) que contiene la información del enlace.</returns>
        public static HtmlLink CrearLinkCSS(Page pagina, Type tipo, string css)
        {
            HtmlLink cssLink = new System.Web.UI.HtmlControls.HtmlLink();
            cssLink.Href = cssLink.Href = pagina.ClientScript.GetWebResourceUrl(tipo, css);
            cssLink.Attributes.Add("rel", "stylesheet");
            cssLink.Attributes.Add("type", "text/css");

            return cssLink;


        }

        //public static T ObtenerControlTipor<T>(string nombre, dynamic root) where T : new()
        //{

        //    if (root.GetType() == typeof(T))
        //        return (T)root;
        //    else
        //    {
        //        foreach (dynamic ctrlsub in root.Controls)
        //        {
        //            if (ctrlsub.GetType() == typeof(T))
        //                return (T)ctrlsub;
        //            if (ctrlsub.HasControls())
        //            {
        //                T ctrlbusqueda = ObtenerControlTipor<T>(nombre, ctrlsub);
        //                if (ctrlbusqueda != null)
        //                    return ctrlbusqueda;
        //            }
        //        }
        //        return default(T);
        //    }
        //}

        //public static Control ObtenerControlh(string nombre, Control root)
        //{

        //    if (root.ID == nombre)
        //        return root;
        //    else
        //    {
        //        foreach (Control ctrlsub in root.Controls)
        //        {
        //            if (ctrlsub.ID == nombre)
        //                return ctrlsub;
        //            if (ctrlsub.HasControls())
        //            {
        //                Control ctrlbusqueda = ObtenerControlh(nombre, ctrlsub);
        //                if (ctrlbusqueda != null)
        //                    return ctrlbusqueda;
        //            }
        //        }
        //        return null;
        //    }
        //}

        /// <summary>
        /// Metodo que se encarga de obtener el URL base del sitio.
        /// </summary>
        /// <returns>Devuelve el valor(System.String) que contiene la url del sito, por ejemplo http://www.misitio.com/admin/</returns>
        public static string GetBaseUrl()
        {
            return ("http://" + HttpContext.Current.Request.Url.Authority + HttpContext.Current.Request.ApplicationPath);
        }

        /// <summary>
        /// Metodo que se encarga de rellenar los campos que se encuentran en la cadena de texto.
        /// Por ejemplo si se quiere mostrar una URL tomando datos de una entidad, se puede colocar: http://sitio.htm?id={clave} y el texto {clave} se reemplaza
        /// por el valor de la propiedad con nombre "clave" de la clase.
        /// </summary>
        /// <param name="datos">Clase que contiene los datos.</param>
        /// <param name="codigo">Codigo en el cual se buscan los campos para reemplazarlo por los valores.</param>
        /// <returns>Devuelve el texto con los valores asignados.</returns>
        public static string RellenarVariablesEntidad(object datos, string codigo)
        {
            System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex("{[a-zA-Z_]*}");
            System.Collections.ArrayList arrayList = new System.Collections.ArrayList();
            foreach (System.Text.RegularExpressions.Match match in regex.Matches(codigo))
            {
                if (!arrayList.Contains(codigo))
                {
                    arrayList.Add(match.Value);
                }
            }
            foreach (string text in arrayList)
            {
                if (text == "{root}")
                {
                    codigo = codigo.Replace(text, Utilerias.GetBaseUrl());
                }
                else
                {
                    object obj;
                    if (datos.GetType() == typeof(DataRowView))
                        obj = (datos as DataRowView)[text.Replace("{", "").Replace("}", "")];
                    else
                        obj = (datos as dynamic).ObtenerValor<object>(text.Replace("{", "").Replace("}", ""));
                    if (obj == null || obj == DBNull.Value)
                        obj = "";
                    if (obj is System.DateTime)
                    {
                        obj = Comun.Convertir<System.DateTime>(obj).ToString("dd/MM/yyyy");
                    }

                    codigo = codigo.Replace(text, obj.ToString());
                }
            }
            return codigo;
        }

        /// <summary>
        /// Metodo que se encarga de obtener el número de serie del DD.
        /// </summary>
        /// <returns>Número de serie del DD.</returns>
        public static string ObtenerSerieDD()
        {
            //string serie_disco = "";
            //ManagementObjectSearcher searcher = new
            // ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");
            //foreach (ManagementObject wmi_HD in searcher.Get())
            //{

            //    if (wmi_HD["InterfaceType"].ToString().ToUpper().Contains("IDE") && wmi_HD["SerialNumber"] != null)
            //        serie_disco = wmi_HD["SerialNumber"].ToString();
            //}
            DirectoryInfo currentDir = new DirectoryInfo(Environment.CurrentDirectory);
            string path = string.Format("win32_logicaldisk.deviceid=\"{0}\"",
                currentDir.Root.Name.Replace("\\", ""));
            ManagementObject disk = new ManagementObject(path);
            disk.Get();

            string serial = disk["VolumeSerialNumber"].ToString();
            return serial;
        }
        /// <summary>
        /// Metodo que se encarga de obtener una subcadena indicando un limite, y si la cadena es menor al limite, se rellena con la cadena que se indique como parametro.
        /// </summary>
        /// <param name="cadena">Cadena de texto a validar.</param>
        /// <param name="max">Maximo de caracteres.</param>
        /// <param name="relleno">Texto de relleno.</param>
        /// <returns>Devuelve el System.String validada.</returns>
        public static string ObtenerSubCadena(string cadena, int max, string relleno)
        {
            string complemento = "";
            cadena = cadena == null ? "" : cadena;

            if (cadena.Length < max)
            {
                for (int caracter = cadena.Length; caracter <= max; caracter++)
                    complemento += relleno;
                return cadena + complemento;
            }
            else
                return cadena.Substring(0, max);



        }
    }
}
